﻿#include "WRWorkTcpComm.h"
#include "Clients/WRWorkTcpCommClientInterfaceActivator.h"
#include "Servers/WRWorkTcpCommServerInterfaceActivator.h"

#include <QHash>
#include <QMutex>
#include <QMutexLocker>

#include "../WRSoft-Utility/WRBasics.h"
#ifdef WRDEBUG
#include "../WRSoft-Utility/Runtime/WRException.h"
#endif

namespace WRWorkTcpComm
{
    //表示客户端接口管理。
    class ClientInterfaceManager
    {
    private:
        //同步锁。
        QMutex m_mutex;
        //按标识索引表。
        QHash<QUuid, WRWorkTcpCommClientInterfaceActivator*> m_table;

    public:
        //初始化。
        inline ClientInterfaceManager(void)
        {
            //add code here
        }
        //释放资源。
        inline ~ClientInterfaceManager(void)
        {
            //add code here
        }

        //获取指定标识的类。
        inline WRWorkTcpCommClientInterfaceActivator* select(const QUuid& uuid)
        {
            QMutexLocker lock(&m_mutex);
            QHash<QUuid, WRWorkTcpCommClientInterfaceActivator*>::ConstIterator iter = m_table.find(uuid);
            if (iter != m_table.end())
            {
                return iter.value();
            }
            return 0;
        }
        //注册新的类。
        inline void enroll(const QUuid& uuid, WRWorkTcpCommClientInterfaceActivator* activator)
        {
            QMutexLocker lock(&m_mutex);
    #ifdef WRDEBUG
            if (m_table.contains(uuid))
            {
                throw WRArgumentException("uuid");
            }
    #endif
            m_table.insert(uuid, activator);
        }
        //取消指定类信息。
        inline void cancel(const QUuid& uuid)
        {
            QMutexLocker lock(&m_mutex);
            m_table.remove(uuid);
        }
    };
    //获取客户端接口管理实例。
    ClientInterfaceManager* clientInterfaceManager(void)
    {
        static ClientInterfaceManager value;
        return &value;
    }
    //登记客户端接口。
    void enrollClientInterface(const QUuid& uuid, WRWorkTcpCommClientInterfaceActivator* activator)
    {
        ClientInterfaceManager* mgr = clientInterfaceManager();
        mgr->enroll(uuid, activator);
    }
    //登记客户端接口。
    void cancelClientInterface(const QUuid& uuid)
    {
        ClientInterfaceManager* mgr = clientInterfaceManager();
        mgr->cancel(uuid);
    }
    //获取客户端接口。
    WRWorkTcpCommClientInterfaceActivator* selectClientInterface(const QUuid& uuid)
    {
        ClientInterfaceManager* mgr = clientInterfaceManager();
        return mgr->select(uuid);
    }

    //表示服务器接口管理。
    class ServerInterfaceManager
    {
    private:
        //同步锁。
        QMutex m_mutex;
        //按标识索引表。
        QHash<QUuid, WRWorkTcpCommServerInterfaceActivator*> m_table;

    public:
        //初始化。
        inline ServerInterfaceManager(void)
        {
            //add code here
        }
        //释放资源。
        inline ~ServerInterfaceManager(void)
        {
            //add code here
        }

        //获取指定标识的类。
        inline WRWorkTcpCommServerInterfaceActivator* select(const QUuid& uuid)
        {
            QMutexLocker lock(&m_mutex);
            QHash<QUuid, WRWorkTcpCommServerInterfaceActivator*>::ConstIterator iter = m_table.find(uuid);
            if (iter != m_table.end())
            {
                return iter.value();
            }
            return 0;
        }
        //注册新的类。
        inline void enroll(const QUuid& uuid, WRWorkTcpCommServerInterfaceActivator* activator)
        {
            QMutexLocker lock(&m_mutex);
    #ifdef WRDEBUG
            if (m_table.contains(uuid))
            {
                throw WRArgumentException("uuid");
            }
    #endif
            m_table.insert(uuid, activator);
        }
        //取消指定类信息。
        inline void cancel(const QUuid& uuid)
        {
            QMutexLocker lock(&m_mutex);
            m_table.remove(uuid);
        }
    };
    //获取服务器接口管理实例。
    ServerInterfaceManager* serverInterfaceManager(void)
    {
        static ServerInterfaceManager value;
        return &value;
    }
    //登记服务器接口。
    void enrollServerInterface(const QUuid& uuid, WRWorkTcpCommServerInterfaceActivator* activator)
    {
        ServerInterfaceManager* mgr = serverInterfaceManager();
        mgr->enroll(uuid, activator);
    }
    //取消服务器接口。
    void cancelServerInterface(const QUuid& uuid)
    {
        ServerInterfaceManager* mgr = serverInterfaceManager();
        mgr->cancel(uuid);
    }
    //获取服务器接口。
    WRWorkTcpCommServerInterfaceActivator* selectServerInterface(const QUuid& uuid)
    {
        ServerInterfaceManager* mgr = serverInterfaceManager();
        return mgr->select(uuid);
    }
}
